Delphi1. Strukturelle Gliederung im Quelltext eines Delphi-Programmes Ein Delphi-Programm besteht aus einer Projekt-Datei mit der Endung .DPR ,einer oder mehreren Quelltextdateien .PAS und einer oder mehreren Masken/Formularbeschreibungsdateien .DFM. Wird ein Modul kompiliert entsteht aus einem .PAS Quelltext eine .DCU oder eine .OBJ Datei. Bei der Kompilation des gesamten Projektes entstehen entweder .EXE Dateien ( Ausführbare Programme ) bzw. .DLL Dateien ( Dynamic Link Library ), eine Modulsammlung die von verschiedenen Progammen gleichzeitig genutzt werden kann. Zur besseren Lesbarkeit werden Blöcke jeweils zwei Zeichen eingerückt, bei Blockende werden die zwei Zeichen wieder zurückgenommen. 1.1. Projektdatei .DPR Die Projektdatei führt alle Module eines Programmes zusammen, führt die Grundinitialisierung der einzelnen Module durch und startet das Programm. Im Normalfall wird die Projektdatei automatisch mit der Erstellung des Programmes verwaltet und ergänzt nur im Falle der Erstellung einer DLL muß manuell eingegriffen werden.Beispiel PROGRAM test1;
USES Modul1 IN 'MODUL1.PAS',
Modul2 IN 'MODUL2.PAS';
{$R *.RES}
BEGIN
APPLICATION.CreateForm(TForm1,Form1);
APPLICATION.CreateForm(TForm2,Form2);
APPLICATION.Run
END.
1.2. Modulquelltext .PAS Jedes Modul beginnt mit einem Unit-Header der aus dem Schlüsselwort UNIT und einem UNIT-Namen besteht und endet mit dem Schlüsselwort END und einem Punkt. Normale Zeilen werden in Delphi mit einem Semikolon abgeschlossen, mit Ausnahme der Schlüsselworte INTERFACE, IMPLEMENTATION und BEGIN sowie unmittelbar vor einem ELSE-Teil einer IF-Anweisung.Eine Unit gliedert sich zunächst in zwei grobe Teile, einer Interface-Sektion (Schlüsselwort INTERFACE) und einer Implementations-Sektion (Schlüsselwort IMPLEMENTATION). In der Interface-Sektion werden die Variablen, Typen und Funktionen aufgeführt, über die die Unit mit anderen Units kommunizieren soll, in der Implementations-Sektion werden interne Variablen, Typen und Funktionen definiert, bzw. die in der Interface-Sektion aufgeführten Funktionen mit Leben gefüllt. Das Schlüsselwort USES bindet andere Module/Units in diese Unit mit ein und stellt deren, in der Interface-Sektion angegebenen Objekte übergreifend in dieser gesamten Unit zur Verfügung. Die USES-Anweisung in der Interface-Sektion stellt darüberhinaus die eingebundenen Module auch den Units zur Verfügung, die diese Unit in ihrer USES-Anweisung einbinden. Alle weiteren unten aufgeführten Konstrukte tauchen nur bei Bedarf auf und dienen dazu, die Unit mit Leben zu füllen. UNIT Modul1;
INTERFACE
USES
Modul2, SysUtils, Wintypes;
TYPE
TIrgendwasanderes = CLASS(Tirgendwas)
PRIVATE
IrgendeinWert : INTEGER;
PROTECTED
IrgendeinBuchstabe : CHAR;
PUBLIC
IrgendeinText : STRING;
CONSTRUCTOR Create ( Aowner : Tcomponent ); OVERRIDE;
DESTRUCTOR Destroy; OVERRIDE;
PUBLISHED
IrgendeinBetrag : REAL;
VAR
Irgendwas : Tirgendwasanderes;
IMPLEMENTATION
USES
NurInternesModul;
TYPE
TNurInternerTyp = INTEGER;
VAR
NurInterneVariable : INTEGER;
PROCEDURE Tuirgendwas;
TYPE
Boolean2 = (TRUE,FALSE);
VAR
Wahr : Boolean2;
BEGIN
Tuedies := 2 * Tuedas;
END;
FUNCTION Waswarrichtig( Diesunddas : Boolean) : STRING;
TYPE
VAR
BEGIN
IF Diesunddas = FALSE THEN
BEGIN
Waswarrichtig := 'Falsch';
END
ELSE
BEGIN
Waswarrichtig := 'Richtig';
END;
END;
DESTRUCTOR Destroy;
TYPE
VAR
BEGIN
Anweisungen ... ;
INHERITED Destroy;
END;
CONSTRUCTOR Create ( AOwner : TComponent );
TYPE
VAR
BEGIN
INHERITED Create( AOwner );
Anweisungen...;
END;
END.
Die Anweisung TYPE kann global im Interface bzw. Implementation Programmteil auftauchen, aber auch lokal innerhalb der einzelnen Funktionen, Prozeduren etc., sie muß aber immer außerhalb des eigentlichen Anweisungsteils erfolgen. Mit der Anweisung TYPE werden eigene Typdeklarationen vereinbart, d.h. angenommen man braucht eine Variable die verschiedene Autotypen darstellen kann, konkret die Werte PKW, LKW und BUS. Im klassischen Befehlsatz würde man eventuell eine numerische Variable deklariern und den jeweiligen Werten eine Bedeutung zuordnen, immer wieder und immer wieder. Einfacher ist man deklariert im Interface-Teil einer häufig benutzten Unit einen Type Autotyp, der Übersicht halber TAutotyp genannt. TYPE TAutotyp = (PKW,LKW,BUS); Dieser Typ kann dann überall in dieser Definition unter TAutotyp wieder verwendet werden. Die Typdeklaration folgt immer dem Muster Typname = Definition. Um Variablen zu definieren muß man in die VAR-Sektion wechseln, d.h. unter den gleichen Bedingungen wie das Schlüsselwort TYPE das Schlüsselwort VAR verwenden. Die Paarungen in der VAR-Sektion haben immer das gleiche Aussehen: Variablenname : Typname; , der Typname kann ein interner, selbstdefinierter oder fremddefinierter Typ sein. VAR Autovariable : TAutotyp; Anzahl : INTEGER: Variablen und Typen die innerhalb einer Funktion oder Prozedur
deklariert werden können auch nur dort benutzt werden. Außerhalb dieser
Funktion können diese Variablen und Typen nicht benutzt werden, es können
aber in anderen Funktionen Typen und Variablen mit gleichem Namen
existieren.
Innerhalb des Anweisungsteils einer Funktion (Wenn hier Funktion steht, gilt identisches für Prozeduren, Construktoren und ähnliches) ist eine der am häufigsten verwendeten Anweisungen die Zuweisung. Die Zuweisung geschieht mittels := , die korrekte Darstellung lautet also: Ziel := Quelle; Das Ziel kann nur eine Variable oder eine Adresse sein, die Quelle kann eine Variable, eine Funktion oder ein Ausdruck sein. Iterationen werden im wesentlichen über drei Konstruktionen durchgeführt: (1) - IF IF (Ausdruck) THEN (Anweisung(en)) ELSE (Anweisung(en) Beispiel: IF Antwort = UPSHIFT('J') THEN
BEGIN
Antwort := ' ';
LoescheSatz(SatzNr);
END
ELSE
BEGIN
Antwort := ' ';
Meldung('Nichts gelöscht !');
END;
END;
Die IF-Anweisung ist die einfachste Form der Iteration. In Abhängigkeit des Ergebnisses eines Ausdrucks wird entweder in den direkt abhängigen Programmblock oder in den ELSE-Programmteil verzweigt. (2) - CASE CASE (Ordinales Ergebnis) OF (Ergebnis): (Anweisung(en)) (Ergebnis): (Anweisung(en)) (Ergebnis): (Anweisung(en)) ELSE (Anweisung(en)) END; Beispiel: CASE Steuerkennzeichen OF
1 : BEGIN
Steuertext := ' Voller Steuersatz ';
END;
2 : BEGIN
Steuertext := ' Halber Steuersatz ';
END;
3 : Steuertext := ' Steuerfrei ';
ELSE
BEGIN
Steuertext := ' Ungültiger Steuersatz';
END;
END;
Die CASE-Anweisung ist eigentlich die Vereinfachungsform eines mehrfach geschachtelten IF-Blocks. In Abhängigkeit eines Wertes im Kopf werden verschiedene Programmteile im CASE-Körper ausgeführt, wenn keiner zutrifft wird entweder keiner, oder wenn ein ELSE-Teil angegeben dann der ELSE-Part durchgeführt. (3) - TRY TRY (Anweisung(en)) FINALLY (Anweisung(en))TRY (Anweisung(en)) EXCEPT (Anweisung(en)) Beispiel: TRY Satz.Lesen; SicherungSatz.AlleWerte := Satz.AlleWerte; Satz.Name1 := 'Heiner Müller'; Satz.Rewrite; FINALLY Satz.Close; END; Die TRY-Struktur besagt letztendlich nichts anderes als folgendes: Versuche alle Anweisungen im TRY Block. Geht irgendwas schief mach in jedem Fall noch FINALLY bevor du "abstürzt" bzw. TRY Anweisungen, bei Fehler bei einer dieser Anweisungen führe EXCEPT-Block aus. Diese Strukturen dienen im wesentlichen dem Schutz vor IO-intensiven Operationen, die unter Umständen auch mal abstürzen bzw. schiefgehen können. |